use base64::{Engine as _, engine::general_purpose};
use std::collections::HashMap;
use std::sync::{Arc, Mutex};
use once_cell::sync::Lazy;
use log::{debug, warn, error};

#[cfg(target_os = "windows")]
use winapi::um::winuser::{GetDC, ReleaseDC};
#[cfg(target_os = "windows")]
use winapi::um::shellapi::ExtractIconW;
#[cfg(target_os = "windows")]
use winapi::um::winuser::DestroyIcon;
#[cfg(target_os = "windows")]
use winapi::um::libloaderapi::GetModuleHandleW;
#[cfg(target_os = "windows")]
use winapi::um::wingdi::{GetDIBits, BITMAPINFOHEADER, BITMAPINFO, DIB_RGB_COLORS};
#[cfg(target_os = "windows")]
use winapi::shared::windef::HBITMAP;
#[cfg(target_os = "windows")]
use winapi::shared::minwindef::DWORD;
#[cfg(target_os = "windows")]
use std::ffi::OsStr;
#[cfg(target_os = "windows")]
use std::os::windows::ffi::OsStrExt;
#[cfg(target_os = "windows")]
use std::mem;
#[cfg(target_os = "windows")]
use image::{ImageBuffer, Rgba, ImageEncoder};
#[cfg(target_os = "windows")]
use std::ptr;

// 全局图标缓存
static ICON_CACHE: Lazy<Arc<Mutex<HashMap<String, Option<String>>>>> = 
    Lazy::new(|| Arc::new(Mutex::new(HashMap::new())));

/// Windows系统下提取图标并转换为base64
/// 使用缓存机制提高性能
#[cfg(target_os = "windows")]
pub fn extract_icon_as_base64(file_path: &str) -> Option<String> {
    // 检查缓存
    {
        let cache = ICON_CACHE.lock().unwrap();
        if let Some(cached_icon) = cache.get(file_path) {
            debug!("从缓存获取图标: {}", file_path);
            return cached_icon.clone();
        }
    }
    
    // 缓存中没有，执行提取
    let result = extract_icon_as_base64_impl(file_path);
    
    // 将结果存入缓存
    {
        let mut cache = ICON_CACHE.lock().unwrap();
        cache.insert(file_path.to_string(), result.clone());
    }
    
    result
}

/// 实际的图标提取实现
#[cfg(target_os = "windows")]
fn extract_icon_as_base64_impl(file_path: &str) -> Option<String> {

    
    debug!("开始提取图标: {}", file_path);
    
    unsafe {
        // 根据文件类型解析目标路径和图标路径
        let (target_path, icon_path, icon_index) = if file_path.to_lowercase().ends_with(".lnk") {
            debug!("检测到.lnk快捷方式文件，尝试解析完整信息");
            if let Some(shortcut_info) = resolve_shortcut_info(file_path) {
                debug!(".lnk快捷方式目标路径: {}", shortcut_info.target_path);
                if let Some(ref icon_path) = shortcut_info.icon_path {
                    debug!(".lnk快捷方式图标路径: {}, 索引: {}", icon_path, shortcut_info.icon_index);
                    // 优先使用配置的图标路径
                    (shortcut_info.target_path, Some(icon_path.clone()), shortcut_info.icon_index)
                } else {
                    debug!(".lnk快捷方式未配置图标路径，使用目标程序图标");
                    (shortcut_info.target_path, None, 0)
                }
            } else {
                debug!(".lnk快捷方式解析失败，使用原路径");
                (file_path.to_string(), None, 0)
            }
        } else if file_path.to_lowercase().ends_with(".url") {
            debug!("检测到.url快捷方式文件，尝试解析目标路径");
            let resolved = resolve_url_target(file_path);
            match &resolved {
                Some(path) => {
                    debug!(".url快捷方式目标路径: {}", path);
                    // 检查解析出的路径类型
                    if path.ends_with(".exe") && std::path::Path::new(path).exists() {
                        debug!(".url解析出有效的可执行文件路径");
                        (path.clone(), None, 0)
                    } else if is_image_file(path) && std::path::Path::new(path).exists() {
                        debug!(".url解析出有效的图片文件路径，直接转换为base64");
                        return convert_image_to_base64(path);
                    } else {
                        debug!(".url解析出的不是有效可执行文件或图片文件，使用后备图标");
                        return get_fallback_icon(file_path);
                    }
                },
                None => {
                    debug!(".url快捷方式解析失败，使用后备图标");
                    return get_fallback_icon(file_path);
                }
            }
        } else {
            debug!("直接使用文件路径: {}", file_path);
            (file_path.to_string(), None, 0)
        };
        
        // 确定最终用于提取图标的路径和索引
        let (final_path, final_index) = if let Some(icon_path) = icon_path {
            debug!("使用配置的图标路径: {}, 索引: {}", icon_path, icon_index);
            (icon_path, icon_index)
        } else if target_path != file_path && std::path::Path::new(&target_path).exists() {
            debug!("使用目标程序路径: {}", target_path);
            (target_path, 0)
        } else {
            debug!("目标路径无效或为UWP应用，尝试从快捷方式本身提取图标: {}", file_path);
            (file_path.to_string(), 0)
        };
        
        // 将路径转换为宽字符
        let final_wide_path: Vec<u16> = OsStr::new(&final_path)
            .encode_wide()
            .chain(std::iter::once(0))
            .collect();
        
        debug!("调用 ExtractIconW 提取图标，路径: {}, 索引: {}", final_path, final_index);
        
        // 优先使用 ExtractIconEx 获取最高质量的图标
        use winapi::um::shellapi::ExtractIconExW;
        let mut large_icon: winapi::shared::windef::HICON = ptr::null_mut();
        let mut small_icon: winapi::shared::windef::HICON = ptr::null_mut();
        
        debug!("尝试使用 ExtractIconExW 获取高质量图标");
        let result = ExtractIconExW(
            final_wide_path.as_ptr(),
            final_index,
            &mut large_icon,
            &mut small_icon,
            1
        );
        
        debug!("ExtractIconExW 返回值: {}, large_icon: {:?}, small_icon: {:?}", 
               result, large_icon, small_icon);
        
        // 优先使用大图标，如果没有则使用小图标
        let selected_icon = if !large_icon.is_null() {
            debug!("使用大图标 (通常32x32或48x48)");
            // 清理小图标
            if !small_icon.is_null() {
                DestroyIcon(small_icon);
            }
            large_icon
        } else if !small_icon.is_null() {
            debug!("使用小图标 (通常16x16)");
            small_icon
        } else {
            debug!("ExtractIconExW 失败，回退到 ExtractIconW");
            
            // 回退到 ExtractIconW
            let hicon = ExtractIconW(
                GetModuleHandleW(ptr::null()),
                final_wide_path.as_ptr(),
                final_index as u32
            );
            
            if hicon.is_null() || hicon as isize <= 1 {
                debug!("ExtractIconW 也失败了，使用后备图标");
                return get_fallback_icon(file_path);
            }
            
            hicon
        };
        
        process_extracted_icon(selected_icon, file_path)
    }
}

/// 处理已提取的图标
/// 
/// # 参数
/// * `hicon` - 图标句柄
/// * `file_path` - 文件路径（用于日志和后备图标）
/// 
/// # 返回值
/// * `Some(String)` - Base64编码的图标数据
/// * `None` - 处理失败
#[cfg(target_os = "windows")]
fn process_extracted_icon(hicon: winapi::shared::windef::HICON, file_path: &str) -> Option<String> {
    use winapi::um::winuser::ICONINFO;
    use winapi::um::winuser::{GetIconInfo, DestroyIcon};
    use winapi::um::wingdi::DeleteObject;
    use std::mem;
    
    unsafe {
        
        debug!("process_extracted_icon: 处理图标句柄 {:?}", hicon as isize);
        
        if hicon.is_null() || hicon as isize <= 1 {
            warn!("图标句柄无效，使用后备图标。句柄值: {}", hicon as isize);
            return get_fallback_icon(file_path);
        }
        
        debug!("图标句柄有效，开始获取图标信息");
        
        // 获取图标信息
        let mut icon_info: ICONINFO = mem::zeroed();
        debug!("调用 GetIconInfo 获取图标信息");
        
        if GetIconInfo(hicon, &mut icon_info) == 0 {
            error!("GetIconInfo 失败，使用后备图标");
            DestroyIcon(hicon);
            return get_fallback_icon(file_path);
        }
        
        debug!("GetIconInfo 成功，hbmColor: {:?}, hbmMask: {:?}", 
                icon_info.hbmColor, icon_info.hbmMask);
        
        // 转换位图为PNG数据
        debug!("开始转换位图为PNG数据");
        let png_data = convert_bitmap_to_png(icon_info.hbmColor);
        match &png_data {
            Some(data) => debug!("位图转换成功，PNG数据大小: {} 字节", data.len()),
            None => error!("位图转换失败")
        }
        
        // 清理资源
        if !icon_info.hbmColor.is_null() {
            DeleteObject(icon_info.hbmColor as *mut _);
        }
        if !icon_info.hbmMask.is_null() {
            DeleteObject(icon_info.hbmMask as *mut _);
        }
        DestroyIcon(hicon);
        
        // 如果成功转换，返回base64编码的PNG数据
        if let Some(data) = png_data {
            let base64_data = general_purpose::STANDARD.encode(data);
            debug!("图标处理完成，base64数据长度: {}", base64_data.len());
            Some(base64_data)
        } else {
            warn!("图标转换失败，使用后备图标");
            get_fallback_icon(file_path)
        }
    }
}

/// 将HBITMAP转换为PNG数据
#[cfg(target_os = "windows")]
fn convert_bitmap_to_png(hbitmap: HBITMAP) -> Option<Vec<u8>> {
    use winapi::um::wingdi::{GetObjectW, BITMAP};
    use std::io::Cursor;
    
    debug!("convert_bitmap_to_png: 开始转换位图，hbitmap: {:?}", hbitmap);
    
    if hbitmap.is_null() {
        error!("convert_bitmap_to_png: hbitmap 为空");
        return None;
    }
    
    unsafe {
        // 获取位图信息
        let mut bitmap: BITMAP = mem::zeroed();
        debug!("convert_bitmap_to_png: 调用 GetObjectW 获取位图信息");
        
        if GetObjectW(hbitmap as *mut _, mem::size_of::<BITMAP>() as i32, &mut bitmap as *mut _ as *mut _) == 0 {
            error!("convert_bitmap_to_png: GetObjectW 失败");
            return None;
        }
        
        debug!("convert_bitmap_to_png: 位图信息 - 宽度: {}, 高度: {}, 位深: {}",
                bitmap.bmWidth, bitmap.bmHeight, bitmap.bmBitsPixel);
        
        let width = bitmap.bmWidth as u32;
        let height = bitmap.bmHeight as u32;
        
        debug!("convert_bitmap_to_png: 位图尺寸 {}x{}", width, height);
        
        if width == 0 || height == 0 || width > 512 || height > 512 {
            error!("convert_bitmap_to_png: 位图尺寸无效或过大 ({}x{})", width, height);
            return None;
        }
        
        debug!("convert_bitmap_to_png: 位图尺寸有效，开始处理");
        
        // 获取设备上下文
        debug!("convert_bitmap_to_png: 获取设备上下文");
        let hdc = GetDC(ptr::null_mut());
        if hdc.is_null() {
            error!("convert_bitmap_to_png: GetDC 失败");
            return None;
        }
        
        // 准备位图信息结构
        debug!("convert_bitmap_to_png: 准备位图信息结构");
        let mut bmi: BITMAPINFO = mem::zeroed();
        bmi.bmiHeader.biSize = mem::size_of::<BITMAPINFOHEADER>() as DWORD;
        bmi.bmiHeader.biWidth = width as i32;
        bmi.bmiHeader.biHeight = -(height as i32); // 负值表示自上而下
        bmi.bmiHeader.biPlanes = 1;
        bmi.bmiHeader.biBitCount = 32;
        bmi.bmiHeader.biCompression = 0; // BI_RGB
        
        // 分配缓冲区
        let buffer_size = (width * height * 4) as usize;
        let mut buffer: Vec<u8> = vec![0; buffer_size];
        
        debug!("convert_bitmap_to_png: 分配缓冲区，大小: {} 字节", buffer_size);
        
        // 获取位图数据
        debug!("convert_bitmap_to_png: 调用 GetDIBits 获取位图数据");
        let result = GetDIBits(
            hdc,
            hbitmap,
            0,
            height,
            buffer.as_mut_ptr() as *mut _,
            &mut bmi,
            DIB_RGB_COLORS
        );
        
        debug!("convert_bitmap_to_png: GetDIBits 返回值: {}", result);
        
        ReleaseDC(ptr::null_mut(), hdc);
        
        if result == 0 {
            error!("convert_bitmap_to_png: GetDIBits 失败");
            return None;
        }
        
        // 转换BGRA到RGBA格式
        debug!("convert_bitmap_to_png: 转换BGRA到RGBA格式");
        for chunk in buffer.chunks_mut(4) {
            chunk.swap(0, 2); // 交换B和R
        }
        
        // 创建图像并编码为PNG
        debug!("convert_bitmap_to_png: 创建图像缓冲区");
        if let Some(img) = ImageBuffer::<Rgba<u8>, Vec<u8>>::from_raw(width, height, buffer) {
            
            // 如果图标尺寸小于48x48，进行高质量放大
            let target_size = if width < 48 || height < 48 {
                debug!("convert_bitmap_to_png: 图标尺寸较小 ({}x{})，进行高质量放大到48x48", width, height);
                48
            } else {
                std::cmp::max(width, height)
            };
            
            // 如果需要缩放，使用高质量的Lanczos3算法
            let final_img = if width != target_size || height != target_size {
                debug!("convert_bitmap_to_png: 使用Lanczos3算法缩放图像到{}x{}", target_size, target_size);
                image::imageops::resize(&img, target_size, target_size, image::imageops::FilterType::Lanczos3)
            } else {
                img
            };
            
            let mut png_data = Vec::new();
            let mut cursor = Cursor::new(&mut png_data);
            
            debug!("convert_bitmap_to_png: 使用高质量设置编码为PNG格式");
            
            // 使用更高质量的PNG编码设置
            use image::codecs::png::{PngEncoder, CompressionType, FilterType};
            let encoder = PngEncoder::new_with_quality(&mut cursor, CompressionType::Best, FilterType::Adaptive);
            
            if encoder.write_image(&final_img, target_size, target_size, image::ColorType::Rgba8).is_ok() {
                debug!("convert_bitmap_to_png: 高质量PNG编码成功，最终尺寸: {}x{}, 数据大小: {} 字节", 
                       target_size, target_size, png_data.len());
                return Some(png_data);
            } else {
                error!("convert_bitmap_to_png: 高质量PNG编码失败，尝试标准编码");
                
                // 回退到标准编码
                png_data.clear();
                cursor = Cursor::new(&mut png_data);
                
                if PngEncoder::new(&mut cursor)
                    .write_image(&final_img, target_size, target_size, image::ColorType::Rgba8)
                    .is_ok() {
                    debug!("convert_bitmap_to_png: 标准PNG编码成功，数据大小: {} 字节", png_data.len());
                    return Some(png_data);
                } else {
                    error!("convert_bitmap_to_png: 标准PNG编码也失败");
                }
            }
        } else {
            error!("convert_bitmap_to_png: 创建图像缓冲区失败");
        }
        
        None
    }
}

/// 检查是否为UWP应用快捷方式
/// 
/// # 参数
/// * `file_path` - 快捷方式文件路径
/// 
/// # 返回值
/// * `bool` - 是否为UWP应用快捷方式
fn is_uwp_app_shortcut(file_path: &str) -> bool {
    // 检查文件名是否包含UWP应用的特征
    let file_name = std::path::Path::new(file_path)
        .file_name()
        .and_then(|name| name.to_str())
        .unwrap_or("");
    
    // UWP应用快捷方式通常包含这些特征
    file_name.contains("_") && (
        file_name.contains("x64") || 
        file_name.contains("x86") || 
        file_name.contains("arm") ||
        file_name.contains("neutral")
    )
}

/// 获取后备图标（SVG格式）
/// 
/// # 参数
/// * `file_path` - 文件路径
/// 
/// # 返回值
/// * `Some(String)` - Base64编码的SVG图标
/// * `None` - 获取失败
pub fn get_fallback_icon(file_path: &str) -> Option<String> {
    debug!("get_fallback_icon: 使用后备图标，文件路径: {}", file_path);
    
    let extension = file_path.split('.').last().unwrap_or("");
    
    debug!("get_fallback_icon: 文件扩展名: {}", extension);
    
    let (svg_icon, _icon_type) = match extension {
        "exe" => {
            debug!("get_fallback_icon: 使用可执行文件图标");
            ("<svg viewBox='0 0 24 24' fill='#4A90E2'><rect x='3' y='3' width='18' height='18' rx='2'/><path d='M9 9h6v6H9z' fill='white'/></svg>", "exe")
        },
        "lnk" => {
            if is_uwp_app_shortcut(file_path) {
                debug!("get_fallback_icon: 使用UWP应用图标");
                ("<svg viewBox='0 0 24 24' fill='#0078D4'><rect x='2' y='2' width='20' height='20' rx='3' fill='#0078D4'/><rect x='4' y='4' width='7' height='7' rx='1' fill='white'/><rect x='13' y='4' width='7' height='7' rx='1' fill='white'/><rect x='4' y='13' width='7' height='7' rx='1' fill='white'/><rect x='13' y='13' width='7' height='7' rx='1' fill='white'/></svg>", "uwp")
            } else {
                debug!("get_fallback_icon: 使用快捷方式图标");
                ("<svg viewBox='0 0 24 24' fill='#FFA500'><path d='M10 6L8.59 7.41 13.17 12l-4.58 4.59L10 18l6-6z'/></svg>", "lnk")
            }
        },
        "url" => {
            debug!("get_fallback_icon: 使用通用URL文件图标");
            ("<svg viewBox='0 0 24 24' fill='#2196F3'><path d='M16.36,14C16.44,13.34 16.5,12.68 16.5,12C16.5,11.32 16.44,10.66 16.36,10H19.74C19.9,10.64 20,11.31 20,12C20,12.69 19.9,13.36 19.74,14M14.59,19.56C15.19,18.45 15.65,17.25 15.97,16H18.92C17.96,17.65 16.43,18.93 14.59,19.56M14.34,14H9.66C9.56,13.34 9.5,12.68 9.5,12C9.5,11.32 9.56,10.65 9.66,10H14.34C14.43,10.65 14.5,11.32 14.5,12C14.5,12.68 14.43,13.34 14.34,14M12,19.96C11.17,18.76 10.5,17.43 10.09,16H13.91C13.5,17.43 12.83,18.76 12,19.96M8,8H5.08C6.03,6.34 7.57,5.06 9.4,4.44C8.8,5.55 8.35,6.75 8,8M5.08,16H8C8.35,17.25 8.8,18.45 9.4,19.56C7.57,18.93 6.03,17.65 5.08,16M4.26,14C4.1,13.36 4,12.69 4,12C4,11.31 4.1,10.64 4.26,10H7.64C7.56,10.66 7.5,11.32 7.5,12C7.5,12.68 7.56,13.34 7.64,14M12,4.03C12.83,5.23 13.5,6.57 13.91,8H10.09C10.5,6.57 11.17,5.23 12,4.03M18.92,8H15.97C15.65,6.75 15.19,5.55 14.59,4.44C16.43,5.07 17.96,6.34 18.92,8Z'/></svg>", "url")
        },
        _ => {
            debug!("get_fallback_icon: 使用默认文件图标");
            ("<svg viewBox='0 0 24 24' fill='#666'><path d='M14,2H6A2,2 0 0,0 4,4V20A2,2 0 0,0 6,22H18A2,2 0 0,0 20,20V8L14,2M18,20H6V4H13V9H18V20Z'/></svg>", "default")
        }
    };
    
    let base64_data = general_purpose::STANDARD.encode(svg_icon);
    debug!("get_fallback_icon: 后备图标数据长度: {}", base64_data.len());
    
    Some(base64_data)
}



/// 快捷方式信息结构体
#[derive(Debug)]
pub struct ShortcutInfo {
    pub target_path: String,
    pub icon_path: Option<String>,
    pub icon_index: i32,
}

/// 解析Windows快捷方式(.lnk)文件的完整信息
/// 使用Windows API获取目标路径和图标信息
/// 
/// # 参数
/// * `lnk_path` - 快捷方式文件的路径
/// 
/// # 返回值
/// * `Some(ShortcutInfo)` - 成功解析的快捷方式信息
/// * `None` - 解析失败
#[cfg(target_os = "windows")]
pub fn resolve_shortcut_info(lnk_path: &str) -> Option<ShortcutInfo> {
    debug!("resolve_shortcut_info: 开始解析快捷方式 {}", lnk_path);
    
    use winapi::um::objbase::CoInitialize;
     use winapi::um::combaseapi::{CoCreateInstance, CoUninitialize};
     use winapi::um::shobjidl_core::IShellLinkW;
     use winapi::um::objidl::IPersistFile;
     use winapi::shared::winerror::S_OK;
     use winapi::shared::guiddef::GUID;
     use winapi::Interface;
    
    unsafe {
        // 初始化COM
        if CoInitialize(ptr::null_mut()) != S_OK {
            error!("resolve_shortcut_info: COM初始化失败");
            return None;
        }
        
        // 创建IShellLink接口
        let clsid_shell_link = GUID {
            Data1: 0x00021401,
            Data2: 0x0000,
            Data3: 0x0000,
            Data4: [0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46],
        };
        
        let mut shell_link: *mut IShellLinkW = ptr::null_mut();
        let hr = CoCreateInstance(
            &clsid_shell_link,
            ptr::null_mut(),
            1, // CLSCTX_INPROC_SERVER
            &IShellLinkW::uuidof(),
            &mut shell_link as *mut *mut IShellLinkW as *mut *mut _,
        );
        
        if hr != S_OK || shell_link.is_null() {
            error!("resolve_shortcut_info: 创建IShellLink失败");
            CoUninitialize();
            return None;
        }
        
        // 获取IPersistFile接口
        let mut persist_file: *mut IPersistFile = ptr::null_mut();
        let hr = (*shell_link).QueryInterface(
            &IPersistFile::uuidof(),
            &mut persist_file as *mut *mut IPersistFile as *mut *mut _,
        );
        
        if hr != S_OK || persist_file.is_null() {
            error!("resolve_shortcut_info: 获取IPersistFile失败");
            (*shell_link).Release();
            CoUninitialize();
            return None;
        }
        
        // 转换路径为宽字符
        let wide_path: Vec<u16> = OsStr::new(lnk_path)
            .encode_wide()
            .chain(std::iter::once(0))
            .collect();
        
        // 加载快捷方式文件
        let hr = (*persist_file).Load(wide_path.as_ptr(), 0);
        if hr != S_OK {
            error!("resolve_shortcut_info: 加载快捷方式文件失败");
            (*persist_file).Release();
            (*shell_link).Release();
            CoUninitialize();
            return None;
        }
        
        // 获取目标路径
        let mut target_path = [0u16; 260]; // MAX_PATH
        let hr = (*shell_link).GetPath(
            target_path.as_mut_ptr(),
            target_path.len() as i32,
            ptr::null_mut(),
            0,
        );
        
        let target = if hr == S_OK {
            let len = target_path.iter().position(|&c| c == 0).unwrap_or(target_path.len());
            let target_str = String::from_utf16_lossy(&target_path[..len]);
            if !target_str.is_empty() {
                debug!("resolve_shortcut_info: 成功解析目标路径: {}", target_str);
                target_str
            } else {
                debug!("resolve_shortcut_info: 目标路径为空，可能是UWP应用快捷方式");
                // 对于UWP应用快捷方式，目标路径可能为空，但仍可能有图标信息
                // 使用快捷方式文件路径作为占位符
                lnk_path.to_string()
            }
        } else {
            debug!("resolve_shortcut_info: 无法获取目标路径，可能是UWP应用快捷方式");
            // 对于某些特殊快捷方式（如UWP应用），GetPath可能失败
            // 但仍可能有图标信息，继续处理
            lnk_path.to_string()
        };
        
        // 获取图标路径和索引
        let mut icon_path = [0u16; 260]; // MAX_PATH
        let mut icon_index: i32 = 0;
        let hr = (*shell_link).GetIconLocation(
            icon_path.as_mut_ptr(),
            icon_path.len() as i32,
            &mut icon_index,
        );
        
        let icon_info = if hr == S_OK {
            let len = icon_path.iter().position(|&c| c == 0).unwrap_or(icon_path.len());
            let icon_path_str = String::from_utf16_lossy(&icon_path[..len]);
            if !icon_path_str.is_empty() {
                debug!("resolve_shortcut_info: 找到图标路径: {}, 索引: {}", icon_path_str, icon_index);
                // 展开环境变量
                let expanded_icon_path = expand_environment_variables(&icon_path_str);
                debug!("resolve_shortcut_info: 展开后的图标路径: {}", expanded_icon_path);
                Some(expanded_icon_path)
            } else {
                debug!("resolve_shortcut_info: 未找到图标路径");
                None
            }
        } else {
            debug!("resolve_shortcut_info: 获取图标路径失败");
            None
        };
        
        // 清理资源
        (*persist_file).Release();
        (*shell_link).Release();
        CoUninitialize();
        
        Some(ShortcutInfo {
            target_path: target,
            icon_path: icon_info,
            icon_index,
        })
    }
}


/// 展开环境变量
/// 
/// # 参数
/// * `path` - 包含环境变量的路径字符串
/// 
/// # 返回值
/// * `String` - 展开后的路径
#[cfg(target_os = "windows")]
fn expand_environment_variables(path: &str) -> String {
    use winapi::um::processenv::ExpandEnvironmentStringsW;
    use std::ffi::OsStr;
    use std::os::windows::ffi::OsStrExt;
    
    // 转换为宽字符
    let wide_path: Vec<u16> = OsStr::new(path)
        .encode_wide()
        .chain(std::iter::once(0))
        .collect();
    
    unsafe {
        // 获取展开后的长度
        let required_size = ExpandEnvironmentStringsW(
            wide_path.as_ptr(),
            std::ptr::null_mut(),
            0,
        );
        
        if required_size == 0 {
            warn!("expand_environment_variables: 无法展开环境变量: {}", path);
            return path.to_string();
        }
        
        // 分配缓冲区并展开
        let mut buffer = vec![0u16; required_size as usize];
        let result = ExpandEnvironmentStringsW(
            wide_path.as_ptr(),
            buffer.as_mut_ptr(),
            required_size,
        );
        
        if result == 0 {
            warn!("expand_environment_variables: 展开环境变量失败: {}", path);
            return path.to_string();
        }
        
        // 转换回字符串
        let len = buffer.iter().position(|&c| c == 0).unwrap_or(buffer.len());
        let expanded = String::from_utf16_lossy(&buffer[..len]);
        debug!("expand_environment_variables: {} -> {}", path, expanded);
        expanded
    }
}


/// 解析Internet快捷方式(.url)文件的目标路径
/// 
/// # 参数
/// * `url_path` - .url文件路径
/// 
/// # 返回值
/// * `Some(String)` - 目标URL或可执行文件路径
/// * `None` - 解析失败
#[cfg(target_os = "windows")]
fn resolve_url_target(url_path: &str) -> Option<String> {
    debug!("resolve_url_target: 开始解析.url文件 {}", url_path);
    
    use std::fs;
    
    // 读取.url文件内容
    match fs::read_to_string(url_path) {
        Ok(content) => {
            debug!("resolve_url_target: 成功读取.url文件内容");
            
            // 首先解析所有字段，收集URL和IconFile信息
            let mut url_value: Option<String> = None;
            let mut icon_file_value: Option<String> = None;
            
            for line in content.lines() {
                let line = line.trim();
                
                // 查找URL字段
                if line.starts_with("URL=") {
                    let url = line[4..].trim();
                    debug!("resolve_url_target: 找到URL: {}", url);
                    url_value = Some(url.to_string());
                }
                
                // 查找IconFile字段（优先使用）
                if line.starts_with("IconFile=") {
                    let icon_file = line[9..].trim();
                    if !icon_file.is_empty() {
                        debug!("resolve_url_target: 找到IconFile: {}", icon_file);
                        icon_file_value = Some(icon_file.to_string());
                    }
                }
            }
            
            // 优先使用IconFile，如果存在且文件有效
            if let Some(icon_file) = icon_file_value {
                if std::path::Path::new(&icon_file).exists() {
                    debug!("resolve_url_target: 使用IconFile: {}", icon_file);
                    return Some(icon_file);
                } else {
                    warn!("resolve_url_target: IconFile不存在: {}", icon_file);
                }
            }
            
            // 如果IconFile不可用，则处理URL
            if let Some(url) = url_value {
                // 对于所有URL，直接返回URL本身
                debug!("resolve_url_target: 返回URL: {}", url);
                return Some(url);
            }
            
            warn!("resolve_url_target: 未找到有效的URL或IconFile字段");
        }
        Err(e) => {
            error!("resolve_url_target: 读取.url文件失败: {}", e);
        }
    }
    
    None
}


/// 检查文件是否为支持的图片格式
/// 
/// # 参数
/// * `file_path` - 文件路径
/// 
/// # 返回值
/// * `bool` - 如果是支持的图片格式则返回true
fn is_image_file(file_path: &str) -> bool {
    let path = file_path.to_lowercase();
    path.ends_with(".jpg") || 
    path.ends_with(".jpeg") || 
    path.ends_with(".png") || 
    path.ends_with(".bmp") || 
    path.ends_with(".ico")
}

/// 将图片文件转换为base64编码
/// 
/// # 参数
/// * `image_path` - 图片文件路径
/// 
/// # 返回值
/// * `Some(String)` - Base64编码的图片数据
/// * `None` - 转换失败
fn convert_image_to_base64(image_path: &str) -> Option<String> {
    debug!("convert_image_to_base64: 开始转换图片文件: {}", image_path);
    
    use std::fs;
    use std::io::Cursor;
    
    // 读取图片文件
    match fs::read(image_path) {
        Ok(image_data) => {
            debug!("convert_image_to_base64: 成功读取图片文件，大小: {} 字节", image_data.len());
            
            // 尝试使用image库解码和重新编码为PNG（确保格式统一）
            match image::load_from_memory(&image_data) {
                Ok(img) => {
                    debug!("convert_image_to_base64: 成功解码图片，尺寸: {}x{}", img.width(), img.height());
                    
                    // 调整图片大小到合适的尺寸（如果太大的话）
                    let resized_img = if img.width() > 256 || img.height() > 256 {
                        debug!("convert_image_to_base64: 图片尺寸过大，调整到256x256");
                        img.resize(256, 256, image::imageops::FilterType::Lanczos3)
                    } else {
                        img
                    };
                    
                    // 转换为PNG格式
                    let mut png_data = Vec::new();
                    let mut cursor = Cursor::new(&mut png_data);
                    
                    match resized_img.write_to(&mut cursor, image::ImageFormat::Png) {
                        Ok(_) => {
                            debug!("convert_image_to_base64: 成功转换为PNG格式，大小: {} 字节", png_data.len());
                            let base64_data = general_purpose::STANDARD.encode(png_data);
                            debug!("convert_image_to_base64: Base64编码完成，长度: {}", base64_data.len());
                            Some(base64_data)
                        }
                        Err(e) => {
                            error!("convert_image_to_base64: PNG编码失败: {}", e);
                            // 如果PNG编码失败，直接返回原始数据的base64
                            debug!("convert_image_to_base64: 使用原始图片数据进行base64编码");
                            let base64_data = general_purpose::STANDARD.encode(image_data);
                            Some(base64_data)
                        }
                    }
                }
                Err(e) => {
                    warn!("convert_image_to_base64: 图片解码失败: {}，使用原始数据", e);
                    // 如果解码失败，直接返回原始数据的base64
                    let base64_data = general_purpose::STANDARD.encode(image_data);
                    debug!("convert_image_to_base64: 原始数据base64编码完成，长度: {}", base64_data.len());
                    Some(base64_data)
                }
            }
        }
        Err(e) => {
            error!("convert_image_to_base64: 读取图片文件失败: {}", e);
            None
        }
    }
}

/// 非Windows系统的占位符实现
#[cfg(not(target_os = "windows"))]
pub fn extract_icon_as_base64(_file_path: &str) -> Option<String> {
    None
}